package com.flca.frw.validators;

import java.math.BigDecimal;
import java.util.Collection;
import java.util.Date;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.joda.time.DateTime;

import com.flca.frw.util.DateUtils;
import com.flca.frw.util.TransformUtils;

/**
 * Validator class is a helper to perform common validations in a very shortcut manner.
 * The idea is that all errors are collection in a List<ValidationError> and these ValidationError objects
 * will be populated correctly by the helper class. Example:
 * <code>
 * List<ValidationError> errors = new ArrayList<ValidationError>();
 * Validator.testNotEmpty(anObject.name, errors, "name", null);
 * Validator.testGreaterThen(anObject.bookingDate, tomorow, errors, "bookingDate", null);
 * </code>
 * The pattern of the test method is the following:
 * <br>
 * first parameter: the value to test. The type depends on the depend. These are often overloaded.
 * <br>
 * second parameter  : Depending on the method another value(s) is (are) required that is used to validate against.
 * for example stringlength has 1 param. DateRange has 2 params.
 * <br>
 * next parameter: The List<ValidationError> that must populated.
 * <br>
 * next parameter: The (String) name of the property (path)
 * <br>
 * next parameter: a String[] array may be given that will be used to format the output.
 * Often this will be null.  
 * 
 * @author Robin Bakkerus 
 */

public final class Validator {


	private static TransformUtils tu = TransformUtils.getInstance();

	private Validator() {
	}
	
	/**
	 * Boolean die gebruikt wordt bij bijv testRange.
	 */
	public static final boolean INCLUSIVE_EQUALS = true;
	/**
	 * Boolean die gebruikt wordt bij bijv testRange.
	 */
	public static final boolean EXCLUSIVE_EQUALS = false;

	/**
	 * Method testIsLeeg.
	 * 
	 * @param testVeld
	 * @param aSignaleringen
	 * @param aOms
	 * @return boolean
	 */
	public static boolean testNotNull(Object testVeld, List<ValidationError> errors, String propName, String parameters[]) {

		if (testVeld == null) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_IS_REQUIRED, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testIsLeeg.
	 * 
	 * @param testVeld
	 * @param aSignaleringen
	 * @param aOms
	 * @return boolean
	 */
	public static boolean testNotEmpty(String testVeld, List<ValidationError> errors, String propName, String parameters[]) {

		if (testVeld == null || testVeld.trim().length() == 0) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_IS_REQUIRED, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testNotEmpty.
	 * 
	 * @param testObj
	 * @param aSignaleringen
	 * @param aOms
	 * @return boolean
	 */
	public static boolean testNotEmpty(Object testObj, List<ValidationError> errors, String propName, String parameters[]) {
		if (testObj == null) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_IS_REQUIRED, parameters));
			return false;
		} else {
			return true;
		}
	}

	public static boolean testCollectionNotEmpty(Collection<?> collection,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (collection == null) {
			errors.add(new ValidationError(propName, ValidationConstants.NO_ELEMENTS, parameters));
			return false;
		} else if (collection.size() == 0) {
			errors.add(new ValidationError(propName, ValidationConstants.NO_ELEMENTS, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testNiet0.
	 * 
	 * @param aValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testNot0(int aValue, List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue == 0) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_EQUALS_0, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testNiet0.
	 * 
	 * @param aValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testNot0(double aValue, List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue == 0.00) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_EQUALS_0, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testGreater. Deze genereert ook Signalering als de waarde gelijk
	 * is!
	 * 
	 * @param aValue
	 * @param aMinValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testGreater(int aValue, int aMinValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue <= aMinValue) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_SMALL, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testGroterGelijkDan.
	 * 
	 * @param aValue
	 * @param aMinValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testGreaterOrEquals(int aValue, int aMinValue, List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue < aMinValue) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_SMALL, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testGreater. Deze genereert ook Signalering als de waarde gelijk
	 * is!
	 * 
	 * @param aValue
	 * @param aMinValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testGreater(Integer aValue, int aMinValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (testNotEmpty(aValue, errors, propName, parameters)) {
			if (aValue.intValue() <= aMinValue) {
				errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_SMALL, parameters));
				return false;
			} else {
				return true;
			}
		} else {
			return false;
		}
	}

	/**
	 * Method testGroterGelijkDan.
	 * 
	 * @param aValue
	 * @param aMinValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testGreaterOrEquals(Integer aValue, int aMinValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (testNotEmpty(aValue, errors, propName, parameters)) {
			if (aValue.intValue() < aMinValue) {
				errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_SMALL, parameters));
				return false;
			} else {
				return true;
			}
		} else {
			return false;
		}
	}

	/**
	 * Method testGreater. Deze genereert ook Signalering als de waarde gelijk
	 * is!
	 * 
	 * @param aValue
	 * @param aMinValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testGreater(double aValue, double aMinValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue <= aMinValue) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_SMALL, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testGroterGelijkDan.
	 * 
	 * @param adoubleValue
	 * @param aMinValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testGreaterOrEquals(double adoubleValue, double aMinValue, List<ValidationError> errors, String propName, String parameters[]) {
		if (adoubleValue < aMinValue) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_SMALL, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testSmaller. Deze genereert ook Signalering als de waarde
	 * gelijk is!
	 * 
	 * @param aValue
	 * @param aMaxValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testSmaller(int aValue, int aMaxValue, List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue >= aMaxValue) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_LARGE, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testKleinerGelijkDan.
	 * 
	 * @param aintValue
	 * @param aMaxValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testSmallerOrEquals(int aintValue, int aMaxValue, List<ValidationError> errors, String propName, String parameters[]) {
		if (aintValue > aMaxValue) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_LARGE, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testSmaller. Deze genereert ook Signalering als de waarde
	 * gelijk is!
	 * 
	 * @param aValue
	 * @param aMaxValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testSmaller(Integer aValue, int aMaxValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (testNotEmpty(aValue, errors, propName, parameters)) {
			if (aValue.intValue() >= aMaxValue) {
				errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_LARGE, parameters));
				return false;
			} else {
				return true;
			}
		} else {
			return false;
		}
	}

	/**
	 * Method testKleinerGelijkDan. Deze genereert ook Signalering als de waarde
	 * gelijk is!
	 * 
	 * @param aValue
	 * @param aMaxValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testSmallerOrEquals(Integer aValue, int aMaxValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (testNotEmpty(aValue, errors, propName, parameters)) {
			if (aValue.intValue() > aMaxValue) {
				errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_LARGE, parameters));
				return false;
			} else {
				return true;
			}
		} else {
			return false;
		}
	}

	/**
	 * Method testSmaller. Deze genereert ook Signalering als de waarde
	 * gelijk is!
	 * 
	 * @param aValue
	 * @param aMaxValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testSmaller(double aValue, double aMaxValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue >= aMaxValue) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_LARGE, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testKleinerGelijkDan.
	 * 
	 * @param aValue
	 * @param aMaxValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testSmallerOrEquals(double aValue, double aMaxValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue > aMaxValue) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_TOO_LARGE, parameters));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testRange. Deze genereert ook Signalering als de waarde gelijk is!
	 * 
	 * @param aValue
	 * @param aMinValue
	 * @param aMaxValue
	 * @param opt
	 * @return boolean
	 */
	public static boolean testRange(int aValue, int aMinValue, int aMaxValue,
			List<ValidationError> errors, String propName, String parameters[]) 
	{
		if (aValue <= aMinValue || aValue >= aMaxValue) {
			String params[] = getParams(parameters, aMinValue, aMaxValue);
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_NOT_IN_RANGE, params));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Method testRange. Deze genereert ook Signalering als de waarde gelijk is!
	 * 
	 */
	public static boolean testRange(double aValue, double aMinValue,
			double aMaxValue, List<ValidationError> errors, String propName, String parameters[]) {

		if (aValue <= aMinValue || aValue >= aMaxValue) {
			String params[] = getParams(parameters, aMinValue, aMaxValue);
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_NOT_IN_RANGE, params));
			return false;
		} else {
			return true;
		}
	}

	/**
	 */
	public static boolean testRange(BigDecimal aTestValue, double aMinValue,
			double aMaxValue, boolean aIncludeEquals, List<ValidationError> errors, String propName, String parameters[]) 
	{
		String params[] = getParams(parameters, aMinValue, aMaxValue);

		if (aIncludeEquals) {
			if (aTestValue != null && 
					aTestValue.doubleValue() >= aMinValue && 
					aTestValue.doubleValue() <= aMaxValue) {
					return true;
				} else {
					errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_NOT_IN_RANGE, params));
					return false;
				}
		} else {
			if (aTestValue != null && 
					aTestValue.doubleValue() > aMinValue && 
					aTestValue.doubleValue() < aMaxValue) {
					return true;
				} else {
					errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_NOT_IN_RANGE, params));
					return false;
				}
		}
	}

	/**
	 * @param aValue
	 * @param aLenth
	 * @param opt
	 * @return
	 */
	public static boolean testStringLength(String aValue, int aMinLenth, int aMaxLength,
			List<ValidationError> errors, String propName, String parameters[]) {

		if (StringUtils.isEmpty(aValue)) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_STRINGLENGTH, parameters));
			return false;
		} else {
			int max = aMaxLength;
			if (max == 0) max = 1000000;
			if (aValue.length() <= max && aValue.length() >= aMinLenth) {
				return true;
			} else {
				errors.add(new ValidationError(propName, ValidationConstants.FIELD_STRINGLENGTH, parameters));
				return false;
			}
		}
	}

	/**
	 * Deze vergelijkt alleen het datum gedeelte, de tijd mag afwijken.
	 * 
	 * @param aValue
	 * @param aVglDate
	 * @param opt
	 * @return
	 */
	public static boolean testEquals(Date aValue, Date aVglDate, List<ValidationError> errors, String propName, String parameters[]) 
	{ // twee datums vergelijken zonder tijd
		DateTime dtA = DateUtils.toDateTime(aValue);
		DateTime dtB = DateUtils.toDateTime(aVglDate);
		if (dtA.equals(dtB)) {
			return true;
		} else {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_NOT_EQUALS_TO, parameters));
			return false;
		}
	}

	/**
	 * @param aValue
	 * @param aVglDate
	 * @param opt
	 * @return
	 */
	public static boolean testGreater(Date aValue, Date aVglDate, List<ValidationError> errors, String propName, String parameters[]) {
		try {
			DateTime dtA = DateUtils.toDateTime(aValue);
			DateTime dtB = DateUtils.toDateTime(aVglDate);
			if (dtA.compareTo(dtB) > 0) {
				return true;
			} else {
				String[] args = new String[] {tu.date2String(aValue), tu.date2String(aVglDate)};
				errors.add(new ValidationError(propName, ValidationConstants.FIELD_DATUM_TOO_NEW, args));
				return false;
			}
		} catch (Exception ex) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_DATUM_TOO_NEW, parameters));
			return false;
		}
	}

	/**
	 * Deze vergelijkt alleen het datum gedeelte, de tijd mag afwijken.
	 * 
	 * @param aValue
	 * @param aVglDate
	 * @param opt
	 * @return boolean
	 */
	public static boolean testGreaterOrEquals(Date aValue, Date aVglDate, List<ValidationError> errors, String propName, String parameters[]) {
		DateTime dtA = DateUtils.toDateTime(aValue);
		DateTime dtB = DateUtils.toDateTime(aVglDate);
		if (dtA.compareTo(dtB) >= 0) {
			return true;
		} else {
			String[] args = new String[] {tu.date2String(aValue), tu.date2String(aVglDate)};
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_DATUM_TOO_NEW, args));
			return false;
		}
	}

	/**
	 * @param aValue
	 * @param aVglDate
	 * @param opt
	 * @return
	 */
	public static boolean testSmaller(Date aValue, Date aVglDate, List<ValidationError> errors, String propName, String parameters[]) {
		DateTime dtA = DateUtils.toDateTime(aValue);
		DateTime dtB = DateUtils.toDateTime(aVglDate);
		if (dtA.compareTo(dtB) < 0) {
			return true;
		} else {
			String[] args = new String[] {tu.date2String(aValue), tu.date2String(aVglDate)};
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_DATUM_TOO_OLD, args));
			return false;
		}
	}

	/**
	 * Method testSmallerOrEquals.
	 * 
	 * @param aValue
	 * @param aVglDate
	 * @param opt
	 * @return boolean
	 */
	public static boolean testSmallerOrEquals(Date aValue, Date aVglDate, List<ValidationError> errors, String propName, String parameters[]) {
		DateTime dtA = DateUtils.toDateTime(aValue);
		DateTime dtB = DateUtils.toDateTime(aVglDate);
		if (dtA.compareTo(dtB) <= 0) {
			return true;
		} else {
			String[] args = new String[] {tu.date2String(aValue), tu.date2String(aVglDate)};
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_DATUM_TOO_OLD, args));
			return false;
		}
	}

	/**
	 * Method testRange. Deze kijkt op een datum binnen de opgegeven range
	 * ligt. Met de boolean kan worden aangegeven op de vergelijking inclusief
	 * de min/max datum moet gelden
	 * 
	 * @param aValue
	 * @param aMinData
	 * @param aMaxDate
	 * @param aGroterGelijkDan
	 *            boolean
	 * @param opt
	 * @return boolean
	 */
	public static boolean testRange(Date aValue, Date aMinDate,
			Date aMaxDate, boolean aGroterGelijkDan, List<ValidationError> errors, String propName, String parameters[]) 
	{
		String params[] = getParams(parameters, aMinDate, aMaxDate);

		boolean ok = true;
		if (aGroterGelijkDan) {
			if (testGreaterOrEquals(aValue, aMinDate, errors, propName, parameters)) {
				if (testSmallerOrEquals(aValue, aMaxDate, errors, propName, params)) {
					return true;
				} else {
					ok = false;
				}
			} else {
				ok = false;
			}
		} else {
			if (testGreater(aValue, aMinDate, errors, propName, params)) {
				if (testSmaller(aValue, aMaxDate, errors, propName, parameters)) {
					return true;
				} else {
					ok = false;
				}
			} else {
				ok = false;
			}
		}

		if (!ok) {
			String[] args = new String[] {tu.date2String(aValue),
					tu.date2String(aMinDate), tu.date2String(aMaxDate)};
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_DATE_UITRANGE, args));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Deze controleert of een bepaalde waarde gelijk is aan een bepaalde waarde.
	 * Als waarde ongelijk is, dan wordt Signalering met foucode
	 * ValidationConstants.ERROR_VELD_ONGELIJK_AAN (16) gezet een de testwaarde plus referntiewaarde
	 * als parameters meegegeven
	 * 
	 * @param aValue
	 *            de waarde die getest moet worden
	 * @param aTestValue
	 *            de refentiewaarde
	 * @param opt
	 * @return
	 */
	public static boolean testEquals(int aValue, int aTestValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue != aTestValue) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_DATE_UITRANGE, new String[] {
					"" + aValue, "" + aTestValue }));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Deze controleert of een bepaalde waarde gelijk is aan een bepaalde waarde.
	 * Als waarde ongelijk is, dan wordt Signalering met foucode
	 * ValidationConstants.ERROR_VELD_ONGELIJK_AAN (16) gezet een de testwaarde plus referntiewaarde
	 * als parameters meegegeven
	 * 
	 * @param aValue
	 *            de waarde die getest moet worden
	 * @param aTestValue
	 *            de refentiewaarde
	 * @param opt
	 * @return
	 */
	public static boolean testEquals(short aValue, short aTestValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue != aTestValue) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_NOT_EQUALS, new String[] {
					"" + aValue, "" + aTestValue }));
			return false;
		} else {
			return true;
		}
	}

	/**
	 * Deze controleert of een bepaalde waarde gelijk is aan een bepaalde waarde.
	 * Als waarde ongelijk is, dan wordt Signalering met foucode
	 * ValidationConstants.ERROR_VELD_ONGELIJK_AAN (16) gezet een de testwaarde plus referntiewaarde
	 * als parameters meegegeven
	 * 
	 * @param aValue
	 *            de waarde die getest moet worden
	 * @param aTestValue
	 *            de refentiewaarde
	 * @param opt
	 * @return
	 */
	public static boolean testEquals(Object aValue, Object aTestValue,
			List<ValidationError> errors, String propName, String parameters[]) {
		if (aValue.equals(aTestValue)) {
			errors.add(new ValidationError(propName, ValidationConstants.FIELD_VALUE_NOT_EQUALS, new String[] {
					"" + aValue, "" + aTestValue }));
			return false;
		} else {
			return true;
		}
	}


	public static boolean testDateInFuture(Date datum, List<ValidationError> errors, String propName, String parameters[]) {
		return Validator.testGreater(datum, new Date(), errors, propName, parameters);
	}
	
	public static boolean testDateInPast(Date datum, List<ValidationError> errors, String propName, String parameters[]) {
		return Validator.testSmaller(datum, new Date(), errors, propName, parameters);
	}

	public static boolean testValidAge(Date datum, int minLeeftijd, int maxLeeftijd, List<ValidationError> errors, String propName, String parameters[]) {
		Date maxDate = DateUtils.plusYear(new Date(), -minLeeftijd);
		Date minDate = DateUtils.plusYear(new Date(), -maxLeeftijd);
		return Validator.testRange(datum, minDate, maxDate, 
				INCLUSIVE_EQUALS, errors, propName, parameters);
	}
	
	//-- these are often used validation in the Dutch finance world --
	
	private static final int MAXIMUM_AANTAL_CIJFERS_POSTBANKNR = 7;
	private static final int AANTAL_CIJFERS_BANKNR = 9;
	private static final int ELF = 11;
	private static final int AANTAL_CIJFERS_SOFINR = 9;
	
	public static boolean testValidBankAccount(String rekeningNummer) {
		// Controleer of het rekeningNummer uit enkel en alleen cijfers bestaat.
		// Hierbij wordt wel eerst gefilterd op punten.
		rekeningNummer = StringUtils.replace(rekeningNummer, ".", "");
		if (rekeningNummer.matches("\\d*")) {
			//Nu wordt de lengte van het rekeninnummer gecontroleerd. Hierbij worden
			//eerst alle voorloopnullen van het nummer afgehaald.
			rekeningNummer = rekeningNummer.replaceFirst("0*", "");
			//Controleer of het een postbanknummer is.
			if (rekeningNummer.length() <= MAXIMUM_AANTAL_CIJFERS_POSTBANKNR) {
				return true;
			} else if (rekeningNummer.length() == AANTAL_CIJFERS_BANKNR) {
				int calculation = 0;
				int counter = AANTAL_CIJFERS_BANKNR;
				while (counter > 0) {
					for (int j = 0; j < rekeningNummer.length(); j++) {
						calculation += (counter * Integer.parseInt(
								String.valueOf(rekeningNummer.charAt(j))));
						counter--;
					}
				}
				if (calculation % ELF == 0) {
					return true;
				}
			} else {
				return false;
			}
		}
		return false;
	}

	public static boolean testValidSofiNumber(String sofiNummer) {
		if (sofiNummer.matches("\\d*")) {
			if (sofiNummer.length() == AANTAL_CIJFERS_SOFINR) {
				double calculation = 0;
				int counter = AANTAL_CIJFERS_SOFINR;
				while (counter > 1) {
					for (int j = 0; j < sofiNummer.length() - 1; j++) {
						calculation += (counter * Integer.parseInt(
								String.valueOf(sofiNummer.charAt(j))));
						counter--;
					}
				}
				calculation = (calculation - Integer.parseInt(
						String.valueOf(sofiNummer.charAt(sofiNummer.length() - 1))));
				calculation /= ELF;
				if (calculation % 1 == 0) {
					return true;
				}
			}
		}
		// als we hier komen is het sofiNummer dus niet goed.
		//signals.addSignalering(ValidationConstants.ERROR_SOFINUMMER_NIET_CORRECT);
		return false;			
	}
	
	private static String[] getParams(String aParameters[], Object aArg1, Object aArg2) 
	{
		if (aParameters != null) {
			return aParameters;
		} else {
			String result[] = new String[2];
			try {
				result[0] = tu.object2String(aArg1);
				result[1] = tu.object2String(aArg2);
			} catch (Exception e) {
//				TODO
			}
			return result;
		}
	}
	

}
